home *** CD-ROM | disk | FTP | other *** search
/ Almathera Ten Pack 3: CDPD 3 / Almathera Ten on Ten - Disc 3: CDPD3.iso / fish / 001-100 / 001-025 / 014 / amiga3d / 3dsubrs.c next >
C/C++ Source or Header  |  1995-03-17  |  10KB  |  409 lines
  1. #include <exec/types.h>
  2. #include <exec/nodes.h>
  3. #include <exec/lists.h>
  4. #include <exec/memory.h>
  5. #include <hardware/blit.h>
  6. #include <hardware/custom.h>
  7. #include <graphics/gfx.h>
  8. #include <graphics/clip.h>
  9. #include <graphics/rastport.h>
  10. #include <graphics/view.h>
  11. #include <graphics/text.h>
  12. #include <graphics/gfxmacros.h>
  13.  
  14. #include <graphics/layers.h>
  15. #include <intuition/intuition.h>
  16. #include <libraries/dos.h>
  17. #include "threed.h"
  18.  
  19. extern UBYTE title[] ;
  20.  
  21. extern struct Custom custom;
  22.  
  23. extern struct TmpRas tmpras;
  24.  
  25. extern struct BitMap bitmap0;
  26. extern struct BitMap bitmap1;
  27.  
  28. extern struct RastPort r[2];
  29. extern struct RastPort *rp[2];
  30.  
  31. extern struct RasInfo ri[2];
  32. extern struct RasInfo *rip[2];
  33.  
  34. extern struct RasInfo *irip;
  35.  
  36. extern WORD pcount ;
  37. extern WORD vcount ;
  38.  
  39. extern UWORD frametoggle ;
  40.  
  41. extern struct Objectinfo *objectinfo ;
  42. extern struct Objectinfo *firstobjectinfo ;
  43. extern struct Objectinfo *cameraobjectinfo ;
  44.  
  45. extern BPTR objectsegment ;
  46.  
  47. extern struct Object *Amiga ;
  48.  
  49. extern struct UV *cameramatrix ;
  50. extern struct Coordinate *cameraposition ;
  51.  
  52. extern long GfxBase;
  53. extern long DosBase;
  54.  
  55. int nullproc();
  56. int addvect();
  57. int subvect();
  58. int roll();
  59. int pitch();
  60. int yaw();
  61. int transpose();
  62.  
  63. int (*subroutines[])() = 
  64. {
  65.     nullproc,
  66.     addvect,
  67.     subvect,
  68.     roll,
  69.     pitch,
  70.     yaw,
  71.     transpose,
  72. };
  73.  
  74.  
  75. /*****************************************************************************/
  76.  
  77. nullproc()
  78. {
  79.     return(FALSE);
  80. }
  81.  
  82. WORD mul3d(a,b)
  83. WORD a,b;
  84. {
  85. LONG c;
  86.  
  87.     c = a * b;
  88.     c += 0x2000;
  89.     c >>= 14;
  90.  
  91.     return((WORD)c);
  92. }
  93.  
  94. roll(bm,sine,cosine)
  95. struct UV *bm;
  96. WORD sine;
  97. WORD cosine;
  98. {
  99.     struct UV tmp;
  100.  
  101.     tmp.uv11 = (WORD)(mul3d(bm->uv11,cosine)+mul3d(bm->uv21,sine));
  102.     tmp.uv21 = (WORD)(mul3d(-bm->uv11,sine)+mul3d(bm->uv21,cosine));
  103.     tmp.uv12 = (WORD)(mul3d(bm->uv12,cosine)+mul3d(bm->uv22,sine));
  104.     tmp.uv22 = (WORD)(mul3d(-bm->uv12,sine)+mul3d(bm->uv22,cosine));
  105.     tmp.uv13 = (WORD)(mul3d(bm->uv13,cosine)+mul3d(bm->uv23,sine));
  106.     tmp.uv23 = (WORD)(mul3d(-bm->uv13,sine)+mul3d(bm->uv23,cosine));
  107.  
  108.     bm->uv11 = tmp.uv11;
  109.     bm->uv21 = tmp.uv21;
  110.     bm->uv12 = tmp.uv12;
  111.     bm->uv22 = tmp.uv22;
  112.     bm->uv13 = tmp.uv13;
  113.     bm->uv23 = tmp.uv23;
  114.  
  115. }
  116.  
  117. yaw(bm,sine,cosine)
  118. struct UV *bm;
  119. WORD sine;
  120. WORD cosine;
  121. {
  122.     struct UV tmp;
  123.  
  124.     tmp.uv11 = (WORD)(mul3d(bm->uv11,cosine)+mul3d(bm->uv31,sine));
  125.     tmp.uv31 = (WORD)(mul3d(-bm->uv11,sine)+mul3d(bm->uv31,cosine));
  126.     tmp.uv12 = (WORD)(mul3d(bm->uv12,cosine)+mul3d(bm->uv32,sine));
  127.     tmp.uv32 = (WORD)(mul3d(-bm->uv12,sine)+mul3d(bm->uv32,cosine));
  128.     tmp.uv13 = (WORD)(mul3d(bm->uv13,cosine)+mul3d(bm->uv33,sine));
  129.     tmp.uv33 = (WORD)(mul3d(-bm->uv13,sine)+mul3d(bm->uv33,cosine));
  130.  
  131.     bm->uv11 = tmp.uv11;
  132.     bm->uv31 = tmp.uv31;
  133.     bm->uv12 = tmp.uv12;
  134.     bm->uv32 = tmp.uv32;
  135.     bm->uv13 = tmp.uv13;
  136.     bm->uv33 = tmp.uv33;
  137.  
  138. }
  139.  
  140. pitch(bm,sine,cosine)
  141. struct UV *bm;
  142. WORD sine;
  143. WORD cosine;
  144. {
  145.     struct UV tmp;
  146.  
  147.     tmp.uv21 = (WORD)(mul3d(bm->uv21,cosine)-mul3d(bm->uv31,sine));
  148.     tmp.uv31 = (WORD)(mul3d(bm->uv21,sine)+mul3d(bm->uv31,cosine));
  149.     tmp.uv22 = (WORD)(mul3d(bm->uv22,cosine)-mul3d(bm->uv32,sine));
  150.     tmp.uv32 = (WORD)(mul3d(bm->uv22,sine)+mul3d(bm->uv32,cosine));
  151.     tmp.uv23 = (WORD)(mul3d(bm->uv23,cosine)-mul3d(bm->uv33,sine));
  152.     tmp.uv33 = (WORD)(mul3d(bm->uv23,sine)+mul3d(bm->uv33,cosine));
  153.  
  154.     bm->uv21 = tmp.uv21;
  155.     bm->uv31 = tmp.uv31;
  156.     bm->uv22 = tmp.uv22;
  157.     bm->uv32 = tmp.uv32;
  158.     bm->uv23 = tmp.uv23;
  159.     bm->uv33 = tmp.uv33;
  160.  
  161. }
  162.  
  163. transform(dest)
  164. struct Coordinate *dest;
  165. {
  166.     LONG zinv = 0x00400000;
  167.  
  168.     dest->z = (dest->z<64) ? 64 : dest->z ;
  169.  
  170.     /* dest->x = (WORD)( ((long)dest->x << 8) / dest->z ); */ 
  171.     /* dest->y = (WORD)( ((long)dest->y << 8) / dest->z ); */
  172.  
  173.     /* new algorithm - figure inverse of z and multiply */
  174.  
  175.     zinv /= dest->z;
  176.  
  177.      dest->x = mul3d(dest->x,(WORD)zinv); 
  178.      dest->y = mul3d(dest->y,(WORD)zinv); 
  179.  
  180.  
  181. #ifdef DEBUG
  182.     printf("transform: dest->x = %lx\n",dest->x);
  183.     printf("transform: dest->y = %lx\n",dest->y);
  184.     printf("transform: dest->z = %lx\n",dest->z);
  185. #endif
  186.  
  187. }
  188.  
  189. perspect(objectnumpoints,objectbufpoints)
  190. WORD objectnumpoints;
  191. struct Coordinate objectbufpoints[];
  192. {
  193.     WORD pointcount = 0;
  194.     struct Coordinate *nextpoint;
  195.  
  196.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  197.     {
  198. #ifdef DEBUG
  199.    printf("perspect: pointcount = %lx\n",pointcount);
  200. #endif
  201.    transform(&objectbufpoints[pointcount]);
  202.     }
  203. }
  204.  
  205. subvect(bp,src,dest)
  206. struct Coordinate *bp;
  207. struct Coordinate *src;
  208. struct Coordinate *dest;
  209. {
  210.  
  211. #ifdef DEBUG
  212.     printf("subvect: src->x = %lx\n",src->x);
  213.     printf("subvect: src->y = %lx\n",src->y);
  214.     printf("subvect: src->z = %lx\n",src->z);
  215. #endif
  216.  
  217.     dest->x = (WORD)(src->x - bp->x);
  218.     dest->y = (WORD)(src->y - bp->y);
  219.     dest->z = (WORD)(src->z - bp->z);
  220.  
  221. #ifdef DEBUG
  222.     printf("subvect: dest->x = %lx\n",dest->x);
  223.     printf("subvect: dest->y = %lx\n",dest->y);
  224.     printf("subvect: dest->z = %lx\n",dest->z);
  225. #endif
  226.  
  227. }
  228.  
  229. addvect(bp,src,dest)
  230. struct Coordinate *bp;
  231. struct Coordinate *src;
  232. struct Coordinate *dest;
  233. {
  234.  
  235. #ifdef DEBUG
  236.     printf("addvect: src->x = %lx\n",src->x);
  237.     printf("addvect: src->y = %lx\n",src->y);
  238.     printf("addvect: src->z = %lx\n",src->z);
  239.     printf("addvect: bp->x = %lx\n",bp->x);
  240.     printf("addvect: bp->y = %lx\n",bp->y);
  241.     printf("addvect: bp->z = %lx\n",bp->z);
  242. #endif
  243.  
  244.     dest->x = (WORD)(src->x + bp->x);
  245.     dest->y = (WORD)(src->y + bp->y);
  246.     dest->z = (WORD)(src->z + bp->z);
  247.  
  248. #ifdef DEBUG
  249.     printf("addvect: dest->x = %lx\n",dest->x);
  250.     printf("addvect: dest->y = %lx\n",dest->y);
  251.     printf("addvect: dest->z = %lx\n",dest->z);
  252. #endif
  253.  
  254. }
  255.  
  256. translate(bp,objectnumpoints,objectbufpoints)
  257. struct Coordinate *bp;
  258. WORD objectnumpoints;
  259. struct Coordinate objectbufpoints[];
  260. {
  261.     WORD pointcount = 0;
  262.  
  263.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  264.     {
  265. #ifdef DEBUG
  266.    printf("translate: pointcount = %lx\n",pointcount);
  267. #endif
  268.    addvect(bp,&objectbufpoints[pointcount],&objectbufpoints[pointcount]);
  269.     }
  270. }
  271.  
  272. transpose(bm)
  273. struct UV *bm;
  274. {
  275.     WORD tmp;
  276.  
  277.     tmp = bm->uv12; bm->uv12 = bm->uv21; bm->uv21 = tmp;
  278.     tmp = bm->uv13; bm->uv13 = bm->uv31; bm->uv31 = tmp;
  279.     tmp = bm->uv23; bm->uv23 = bm->uv32; bm->uv32 = tmp;
  280. }
  281.  
  282. cat(dest,src1,src2)
  283. struct UV *dest;
  284. struct UV *src1;
  285. struct UV *src2;
  286. {
  287.    matrix(&dest->uv11,&src1->uv11,src2);
  288.    matrix(&dest->uv21,&src1->uv21,src2);
  289.    matrix(&dest->uv31,&src1->uv31,src2);
  290. }
  291.  
  292. matrix(dest,src,bm)
  293. struct Coordinate *dest;
  294. struct Coordinate *src;
  295. struct UV *bm;
  296. {
  297.  
  298. #ifdef DEBUG
  299.     printf("matrix: src->x = %lx\n",src->x);
  300.     printf("matrix: src->y = %lx\n",src->y);
  301.     printf("matrix: src->z = %lx\n",src->z);
  302. #endif
  303.  
  304.     dest->x = (WORD)(mul3d(src->x,bm->uv11)+mul3d(src->y,bm->uv12)+mul3d(src->z,bm->uv13));
  305.     dest->y = (WORD)(mul3d(src->x,bm->uv21)+mul3d(src->y,bm->uv22)+mul3d(src->z,bm->uv23));
  306.     dest->z = (WORD)(mul3d(src->x,bm->uv31)+mul3d(src->y,bm->uv32)+mul3d(src->z,bm->uv33));
  307.  
  308. #ifdef DEBUG
  309.     printf("matrix: dest->x = %lx\n",dest->x);
  310.     printf("matrix: dest->y = %lx\n",dest->y);
  311.     printf("matrix: dest->z = %lx\n",dest->z);
  312. #endif
  313.  
  314. }
  315.  
  316. rotate(bm,objectnumpoints,pointstart,objectbufpoints)
  317. struct UV *bm;
  318. WORD objectnumpoints;
  319. struct Coordinate *pointstart[];
  320. struct Coordinate objectbufpoints[];
  321. {
  322.     WORD pointcount = 0;
  323.  
  324.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  325.     {
  326. #ifdef DEBUG
  327.    printf("rotate: pointcount = %lx\n",pointcount);
  328. #endif
  329.    matrix(&objectbufpoints[pointcount],pointstart[pointcount],bm);
  330.     }
  331. }
  332.  
  333. copynormals(objectnumpoints,pointstart,objectbufpoints)
  334. WORD objectnumpoints;
  335. struct Coordinate *pointstart[];
  336. struct Coordinate objectbufpoints[];
  337. {
  338.     WORD pointcount = 0;
  339.  
  340.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  341.     {
  342. #ifdef DEBUG
  343.    printf("copynormals: pointcount = %lx\n",pointcount);
  344. #endif
  345.    objectbufpoints[pointcount] = *(pointstart[pointcount]);
  346.     }
  347.  
  348. }
  349.  
  350. camera(bm,bp,objectnumpoints,srcbufpoints,destbufpoints)
  351. struct UV *bm;
  352. struct Coordinate *bp;
  353. WORD objectnumpoints;
  354. struct Coordinate srcbufpoints[];
  355. struct Coordinate destbufpoints[];
  356. {
  357.     WORD pointcount = 0;
  358.  
  359.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  360.     {
  361. #ifdef DEBUG
  362.    printf("camera: pointcount = %lx\n",pointcount);
  363. #endif
  364.    subvect(bp,&destbufpoints[pointcount],&srcbufpoints[pointcount]);
  365.    matrix(&destbufpoints[pointcount],&srcbufpoints[pointcount],bm);
  366.    transform(&destbufpoints[pointcount]);
  367.     }
  368. }
  369.  
  370. notransformdopoints(bm,bp,objectnumpoints,pointstart,objectbufpoints)
  371. struct UV *bm;
  372. struct Coordinate *bp;
  373. WORD objectnumpoints;
  374. struct Coordinate *pointstart[];
  375. struct Coordinate objectbufpoints[];
  376. {
  377.     WORD pointcount = 0;
  378.  
  379.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  380.     {
  381. #ifdef DEBUG
  382.    printf("notransformdopoints: pointcount = %lx\n",pointcount);
  383. #endif
  384.    matrix(&objectbufpoints[pointcount],pointstart[pointcount],bm);
  385.    addvect(bp,&objectbufpoints[pointcount],&objectbufpoints[pointcount]);
  386.     }
  387. }
  388.  
  389. dopoints(bm,bp,objectnumpoints,pointstart,objectbufpoints)
  390. struct UV *bm;
  391. struct Coordinate *bp;
  392. WORD objectnumpoints;
  393. struct Coordinate *pointstart[];
  394. struct Coordinate objectbufpoints[];
  395. {
  396.     WORD pointcount = 0;
  397.  
  398.     for(pointcount = 0; pointcount < objectnumpoints; pointcount++)
  399.     {
  400. #ifdef DEBUG
  401.    printf("dopoints: pointcount = %lx\n",pointcount);
  402. #endif
  403.    matrix(&objectbufpoints[pointcount],pointstart[pointcount],bm);
  404.    addvect(bp,&objectbufpoints[pointcount],&objectbufpoints[pointcount]);
  405.    transform(&objectbufpoints[pointcount]);
  406.     }
  407. }
  408.  
  409.